Thema heute. Im ausgedruckten Skript sind jetzt zwei Abschnitte mit ergänzenden

Materialien tituliert. Das ist etwas, da hatten wir aus einem früheren Durchlauf

von der Vorlesung, hatten wir einfach dieses Material vorbereitet, also ein

bisschen Hintergrund zur Assembler- Programmierung und die unterste

Ebene von Maschinebene- Geschichten. Und da haben wir aber gedacht, das stellen wir

zurück, weil uns das sonst, gut jetzt im Wintersemester hätten wir es vielleicht

sogar noch hinbekommen mit der SPR 1, aber gerade im Sommersemester mit der SPR 1

reicht uns das dann hinten und vorne nicht von der Zeit her.

Wir wollten die Materialien aber jetzt nicht einfach wieder in der Versenkung

verschwinden lassen, nachdem sie existieren.

Sie sind aber, diese ergänzenden Materialien sind jeweils nicht

klausurrelevant, also das kann ich zumindest soweit sagen.

Wir hatten das letzte Mal über diese Schichtenstruktur bei der Rechner

Organisation gesprochen und Thema heute ist jetzt die Betriebssystem-Ebene, also

diese Ebene 3, wenn wir uns vielleicht noch mal dran erinnern.

Irgendwo hatte ich, hatten wir in der letzten Vorlesung dieses Bild hier mit

den verschiedenen Ebenen und die wesentliche Ebene eigentlich für diese

Lehrveranstaltung ist natürlich diese Ebene 3, also letztendlich die Ebene auf

der wir ein Maschinenprogramm vorliegen haben, aber wo in einzelnen Fällen aus

diversen Gründen eben das Betriebssystem aktiv wird und letztendlich

unterstützend irgendwie eingreift und wie dieses unterstützende Eingreifen

funktioniert und was es bedeutet, darum soll es also nun heute gehen.

Es geht um mehrere Themen dabei, das eine ist, wie überhaupt dieses

Betriebssystem in den Ablauf von, in den Programmablauf involviert ist, ist diese

partielle Interpretation. Man kann auch sagen, was wir hier vorliegen haben, ist

eine hybride Maschine, einerseits nämlich die reale Maschine, die CPU, die ein

Großteil des Anwendungsprogramms ausführt und dann die durch das

Betriebssystem gebildete, ja virtuelle Maschine, die eben manche Befehle dann

interpretierend ausführt. Das schauen wir uns dann mal an. Dann geht es darum, wie

passiert eigentlich der Übergang zwischen den Abläufen der realen Maschine und

dieser Betriebssystemmaschine. Es gibt also zwei Gründe dafür, dass das

passieren kann. Das sind die Traps und die Interrupts, also Programmunterbrechungen,

die zu diesem Wechsel führen. Die Frage ist natürlich, wenn man so einen Wechsel

macht, dann unterbricht ein Programmablauf, dann muss man den Laufzeitkontext, also

letztendlich den Zustand des Programms in irgendeiner Weise sichern und

wiederherstellen. Das ist also dann auch ein wesentlicher Punkt und eine ganz

blöde Geschichte ist natürlich, wenn wir so eine Unterbrechung in den

Programmablauf bekommen zu irgendeinem Zeitpunkt, den wir nicht

vorhersagen können und die Unterbrechungsbehandlung am Ende auch

noch irgendetwas macht, was vielleicht von Daten her mit dem normalen Ablauf, der

da unterbrochen wurde, interferiert. Dann können da also ganz unangenehme

Dinge passieren und eben diese konkurrierende Behandlung von normalen

Abläufen und Unterbrechungsbehandlungen und dadurch entstehenden Probleme werde

ich dann aus dem vierten Abschnitt noch kurz erläutern und ganz kurz mal darauf

eingehen, wie man da eben koordinierend eingreifen kann.

Das wird nochmal ein Thema ein bisschen weiter hinten in der Vorlesung, wenn es

um Prozesse geht und in den Übungen dann mit der Threat-Programmierung so ein

ganz bisschen und so richtig ein dickes Thema wird es dann in der nächsten

Semester in der Systemprogrammierung 2, wo wir dann also einen

größeren Abschnitt, also so drei, vier Vorlesungen lang zum Thema Koordinierung